1. Field of the Invention
The present invention relates generally to application development tools for computer applications, and particularly a method and system for an application builder that can optionally generate code used for debugging or testing purposes.
2. Description of the Prior Art
Application builders are software development tools that enable the development of computer applications at an abstraction level that is higher than writing source code. An application builder typically has a graphical user interface through which the developer interacts to create the higher-level representation of the application. The application builder has a code generator component that translates the high-level representation to a concrete representation, which is typically source code, which can then be compiled and run.
The higher level of abstraction offered by application builders makes them useful in tackling today's complex application development. However, the fact that the developer works at an abstraction level that is higher than source code can make debugging and testing harder, since debuggers work at the source code level.
The ability to have source code that is used only in “debug” mode is known in the art. For example, the preprocessor of C and C++ provides such a facility through #if and #ifdef statements, and having statements of the form “#ifdef DEBUG . . . ” in an application is common practice. However, having such a facility at the abstraction level of the application builder is not known in the art.
Within an application builder, having selective code generation is also known in the art. For example, the Rational Rose UML builder (http://www.rational.com/products/rose/index.jsp) lets the developer turn on and off code generation for any given object, where the typical use is to disable code generation for an object while it is still “half-baked”. However, there is no logical grouping of the objects that are turned off and no easy way to toggle between generation and non-generation for a set of objects.
Also known in the art are various techniques for adding debug-specific objects within an application builder framework. However, all such known techniques require the developer to implement some non-trivial aspect of such objects.
Therefore, a need exists in the art for a simple mechanism that lets developers add debug-specific objects within an application builder at a high level of abstraction.
It would be highly desirable to provide a simple mechanism that lets software developers add debug-specific objects within an application builder at a high level of abstraction. Such a development tool should enable the effortless creation and employment of a dedicated debug object, or, advantageously enable any object that normally participates in an application to serve as a debug object.